{"componentChunkName":"component---src-templates-post-jsx","path":"/[NextStep]2/","result":{"data":{"site":{"siteMetadata":{"title":"SUbbb"}},"markdownRemark":{"id":"0a455dd6-0b0a-5012-adf7-ca17d9590acd","excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. \"테스트와 리팩토링은 개발자가 갖추어야 할 중요한 역량이다.\" 🚩 main() 메소드를 활용한 테스트의 문제점 일반적인 테스트 방법은  메소드를 활용해 우리가 의도한 결과 값이 정상적으로 출력되는지를 콘솔을 통해 확인하는 것이다. 🔧 계산기 코드 실제 서비스를 담당하…","html":"<p><em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em></p>\n<blockquote>\n<p><strong>\"테스트와 리팩토링은 개발자가 갖추어야 할 중요한 역량이다.\"</strong></p>\n</blockquote>\n<h2>🚩 main() 메소드를 활용한 테스트의 문제점</h2>\n<p>일반적인 테스트 방법은 <code class=\"language-text\">main()</code> 메소드를 활용해 우리가 의도한 결과 값이 정상적으로 출력되는지를 콘솔을 통해 확인하는 것이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class Calculator {\n    int add (int x, int y) {\n        return x + y;\n    }\n    int subtract (int x, int y) {\n        return x - y;\n    }\n    int multiply (int x, int y) {\n        return x * y;\n    }\n    int divide (int x, int y) {\n        return x / y;\n    }\n\n    public static void main(String[] args) {\n        Calculator cal = new Calculator();\n\n        System.out.println(cal.add(3,4));\n        System.out.println(cal.subtract(5,4));\n        System.out.println(cal.multiply(2,6));\n        System.out.println(cal.divide(8,4));\n    }\n}</code>\n        </deckgo-highlight-code>\n<h3>🔧 계산기 코드</h3>\n<ul>\n<li>\n<p>실제 서비스를 담당하는 프로덕션 코드(production code)와 이 프로덕션 코드가 정상 동작하는지 확인하는 <code class=\"language-text\">main()</code> 으로 나뉜다.</p>\n<ul>\n<li>일반적으로 <code class=\"language-text\">main()</code> 은 <strong>프로그래밍을 실행하기 위한 목적</strong>과 <strong>프로덕션 코드가 정상 동작하는지 확인하기 위한 목적</strong>으로 나뉜다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>🧭 코드의 문제점!</strong></p>\n<ul>\n<li>\n<p>프로덕션 코드와 테스트 코드(<code class=\"language-text\">main()</code> 메소드)가 같은 클래스에 위치하고 있다.</p>\n<ul>\n<li>테스트 코드의 경우 테스트 단계에서만 필요하므로 굳이 서비스하는 시점에 같이 배포할 필요가 없다. </li>\n<li>따라서 문제 해결을 위해 <strong>프로덕션 코드(<code class=\"language-text\">Calculator</code> 클래스)와 테스트 코드(<code class=\"language-text\">CalculatorTest</code>)를 분리</strong>한다.</li>\n</ul>\n</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class CalcultorTest {\n    public static void main(String[] args) {\n        Calculator cal = new Calculator();\n\n        System.out.println(cal.add(3,4));\n        System.out.println(cal.subtract(5,4));\n        System.out.println(cal.multiply(2,6));\n        System.out.println(cal.divide(8,4));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>테스트를 담당하는 별도의 클래스를 추가했지만 <code class=\"language-text\">main()</code> 메소드 하나에 프로덕션 코드의 여러 메소드를 동시에 테스트하고 있다.</p>\n<ul>\n<li>프로덕션 코드의 복잡도가 증가할수록, <code class=\"language-text\">main()</code> 메소드의 복잡도도 증가하게 되고, 이는 결과적으로 <strong><code class=\"language-text\">main()</code> 메소드 유지에 부담</strong>이 된다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>함수 유지 보수를 위해 테스트 코드를 각 메소드별 분리</p>\n</blockquote>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class CalcultorTest {\n    public static void main(String[] args) {\n        // main에서는 함수 호출만 수행\n        Calculator cal = new Calculator();\n\n        add(cal);\n        subtract(cal);\n        multiply(cal);\n        divide(cal);\n    }\n\n    private static void divide(Calculator cal) {\n        System.out.println(cal.divide(8,4));\n    }\n    private static void multiply(Calculator cal) {\n        System.out.println(cal.multiply(2,6));\n    }\n    private static void subtract(Calculator cal) {\n        System.out.println(cal.subtract(5,4));\n    }\n    private static void add(Calculator cal) {\n        System.out.println(cal.add(3,4));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>이 또한 개발자가 프로그래밍하는 과정을 살펴보면, 2가지 이유에서 결국 최종적인 해결책이 될 수 없음을 알 수 있다.</p>\n<ul>\n<li>클래스가 가지고 있는 모든 메소드에 관심이 있는 것이 아니라 <strong>현재 내가 구현하는 메소드에만 집중</strong>하고 싶다.</li>\n<li>하지만 위 테스트 코드는 <code class=\"language-text\">Calculator</code> 클래스의 모든 메소드를 테스트할 수 밖에 없다.</li>\n<li>그렇다고 다른 메소드를 주석 처리하는 것 또한 불합리적이다.</li>\n</ul>\n</li>\n<li>\n<p>또 다른 문제점은, 테스트 결과를 매번 콘솔에 출력되는 값을 통해 <strong>수동으로 확인</strong>해야 한다는 것이다.</p>\n<ul>\n<li>로직이 간단한 경우에는 결과 값을 쉽게 예측할 수 있다.</li>\n<li>하지만 로직의 복잡도가 높은 경우, 후에 결과 값을 예측하는 것은 매우 번거롭고, 시간이 걸리는 작업일 것이다.</li>\n</ul>\n</li>\n</ul>\n<p><code class=\"language-text\">main()</code> 메소드를 활용한 테스트의 이 같은 문제점을 해결하기 위해 등장한 라이브러리가 <strong><code class=\"language-text\">JUnit</code></strong> 이다. </p>\n<ul>\n<li>이는 <strong>내가 관심 가지는 메소드에 대한 테스트만 가능</strong>하고 로직 실행 후의 <strong>결과 값 확인을 프로그래밍을 통해 자동화</strong>하는 것이 가능하다.</li>\n</ul>\n<h3>🔧 JUnit을 활용해 main() 메소드 문제점 극복</h3>\n<p><a href=\"http://junit.org\">JUnit</a>은 단위 테스트 프레임워크 중 하나이다. 사용하기 쉽고 학습 비용이 낮은 라이브러리이다.</p>\n<p><strong>🧭 첫 번째 문제 해결, 한 번에 메소드 하나에만 집중</strong></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import org.junit.Test;\n\npublic class CalculatorTest {\n\n    @Test\n    public void add() {\n        Calculator cal = new Calculator();\n        System.out.println(cal.add(6,3));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><strong>JUnit</strong>은 테스트 메소드에 <code class=\"language-text\">@Test</code> annotation을 추가한다. (테스트 메소드로 인식하기 위함!)</li>\n<li>위와 같은 방법으로 다른 메소드 코드도 작성한다. </li>\n<li>\n<p><strong>JUnit</strong> 기반으로 테스트 코드를 구현하면 <code class=\"language-text\">CalculatorTest</code> 클래스가 가지는 전체 메소드를 한 번에 실행할 수도 있으며, 메소드 각각을 실행할 수도 있다.</p>\n<ul>\n<li>다른 메소드에 영향을 받지 않고 구현 중인 프로덕션 코드에 집중할 수 있다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>\"<strong>중요한 것은, 테스트 코드는 작성한 순서대로 실행되지 않는다!</strong>\"</p>\n</blockquote>\n<p><strong>🧭 두 번째 문제 해결, 결과 값을 눈이 아닌 프로그램을 통해 자동화</strong></p>\n<ul>\n<li><code class=\"language-text\">main()</code> 메소드의 두 번째 문제점은 실행 결과를 눈으로 직접 확인해야 한다는 것이다. <strong>JUnit</strong>은 이 문제점 극복을 위해 <code class=\"language-text\">assertEquals()</code> 메소드를 제공한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.assertEquals;\nimport org.junit.Test;\n\npublic class CalculatorTest {\n\n    @Test\n    public void add() {\n        Calculator cal = new Calculator();\n        assertEquals(9, cal.add(6,3));\n    }\n\n    @Test\n    public void subtract() {\n        Calculator cal = new Calculator();\n        assertEquals(3, cal.subtract(6,3));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">assertEquals</code> 는 static 메소드이므로 <code class=\"language-text\">import static</code> 으로 메소드를 import하여 사용해야 한다.</li>\n<li>메소드의 첫 번째 인자는 <strong>기대하는 결과값(expected)</strong> 이고, 두 번째 인자는 프로덕션 코드의 <strong>메소드를 실행한 결과값(actual)</strong> 이다.</li>\n<li><code class=\"language-text\">int</code>, <code class=\"language-text\">long</code>, <code class=\"language-text\">String</code> 등 다양한 데이터 타입을 지원한다.</li>\n<li>테스트가 실패한 경우는 아래 상태창에서 실패 원인을 확인할 수 있다.</li>\n</ul>\n<p><strong>JUnit</strong>의 <code class=\"language-text\">assertEquals()</code> 메소드를 활용하면 실행 결과를 자동화하는 것이 가능하다. <strong>JUnit</strong>의 <code class=\"language-text\">Assert</code> 클래스는 이외에도 다음과 같은 메소드를 제공한다.</p>\n<ul>\n<li>결과 값의 T/F 유무를 확인하는 <code class=\"language-text\">assertTrue()</code>, <code class=\"language-text\">assertFalse()</code></li>\n<li>결과 값의 null 유무를 판단하는 <code class=\"language-text\">assertNull()</code>, <code class=\"language-text\">assertNotNull()</code></li>\n<li>배열 값이 같은지 검증하는 <code class=\"language-text\">assertArrayEquals()</code></li>\n</ul>\n<p><strong>🧭 테스트 코드 중복 제거</strong></p>\n<blockquote>\n<p><strong>\"개발자가 가져야 할 좋은 습관 중 하나는 중복 코드를 제거하는 것이다.\"</strong></p>\n</blockquote>\n<p>앞서 구현한 <code class=\"language-text\">CalculatorTest</code> 클래스에서, <code class=\"language-text\">Calculator</code> 인스턴스를 생성하는 부분에서 중복이 발생한다. 이러한 중복을 다음과 같이 제거할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class CalculatorTest {\n    private Calculator cal = new Calculator();\n\n    @Test\n    public void add() {\n        assertEquals(9, cal.add(6,3));\n    }\n\n    @Test\n    public void subtract() {\n        assertEquals(3, cal.subtract(6,3));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>이러한 방식은 자바 문법에 있어 아무런 문제가 되지 않지만, <strong>JUnit</strong>은 테스트를 실행하기 위한 초기화 작업을 이렇게 하지 않고 <code class=\"language-text\">@Before</code> annotation을 활용하는 것을 추천한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class CalculatorTest {\n    private Calculator cal;\n\n    @Before\n    public void setup() {\n        cal = new Calculator();\n    }\n    @Test\n    public void add() {\n        assertEquals(9, cal.add(6,3));\n    }\n\n    @Test\n    public void subtract() {\n        assertEquals(3, cal.subtract(6,3));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>이와 같이 <code class=\"language-text\">@Before</code> annotation을 활용하여도 각 단위 테스트를 실행할 때마다 <code class=\"language-text\">Calculator</code> 인스턴스를 생성하는 것은 같다.</p>\n<ul>\n<li>이렇게 매 테스트마다 <code class=\"language-text\">Calculator</code> 인스턴스를 생성하는 이유는 <strong>특정 테스트 메소드를 실행할 때, <code class=\"language-text\">Calculator</code> 의 상태 값이 변경되어 다음 메소드에 영향을 미칠 수 있기 때문</strong>이다.</li>\n<li>다음 테스트 메소드에 영향을 미치게 되면, 테스트 실행 순서나 <code class=\"language-text\">Calculator</code> 의 상태 값에 따라 테스트의 성공 여부가 달라질 수 있다.</li>\n</ul>\n</li>\n</ul>\n<p>그럼에도 코딩량이 더 많아 구현 비용이 큰 <code class=\"language-text\">@Before</code> annotation을 사용하는 이유는 다음과 같다.</p>\n<ul>\n<li><strong>JUnit</strong>에는 <code class=\"language-text\">@RunWith</code>, <code class=\"language-text\">@Rule</code> 같은 annotation을 사용해 기능을 확장할 수 있는데, <code class=\"language-text\">@Before</code> 안이어야만 해당 annotation에서 초기화된 객체 접근할 수 있기 때문이다.</li>\n<li>따라서, 가능한 <code class=\"language-text\">@Before</code> annotation을 사용해 테스트 메소드에 대한 초기화 작업을 하는 것이 문제 발생의 가능성을 낮춰준다.</li>\n</ul>\n<p><code class=\"language-text\">@Before</code> annotation과 비슷하게, <code class=\"language-text\">@After</code> annotation으로 메소드 실행이 끝난 후 후처리 작업을 담당하는 annotation도 존재한다.</p>\n<h3>🔧 문자열 계산기 요구사항 및 실습</h3>\n<p><strong>요구사항</strong>: 전달하는 문자를 구분자로 분리한 후 각 숫자의 합을 구해 반환해야 한다.</p>\n<ul>\n<li>쉼표 또는 콜론을 구분자로 가지는 문자열을 전달하는 경우 구분자를 기준으로 분리한 각 숫자의 합을 반환</li>\n<li>위의 기본 구분자 외에 Custom 구분자를 지정할 수 있다. Custom 구분자는 문자열 앞부분의 \"//\"와 \"\\n\" 사이에 위치하는 문자로 사용</li>\n<li>문자열 계산기에 음수를 전달하는 경우 <code class=\"language-text\">RuntimeException</code> 으로 예외 처리</li>\n</ul>\n<p>간단해보이지만 구현을 바로 시작하지 않고, 요구사항을 더 작은 단위로 나눠 테스트할 경우의 수를 분리해본다.</p>\n<p><strong>🧭 요구사항 분리 및 각 단계별 힌트</strong></p>\n<ul>\n<li>최대한 힌트 없이 진행 !</li>\n</ul>\n<p><strong>🧭 추가 요구사항</strong></p>\n<ul>\n<li>요구사항을 만족하는 코드를 구현했다고 해서 개발이 완료된 것은 아니다. 구현 완료 이후, <strong>중복 제거 &#x26; 읽기 좋은 코드 구현을 위한 리팩토링(구조 변경)</strong>이 이뤄져야 한다.</li>\n</ul>\n<blockquote>\n<p><strong>리팩토링</strong>\n: 소스코드의 가독성을 높이고 유지보수를 편하게 하기 위해 소스코드의 구조를 변경하는 것을 의미한다. 리팩토링을 하더라도 기능상의 결과가 변경되는 것은 아니다.</p>\n</blockquote>\n<p>다음은 <strong>추가적인 요구사항</strong>이다.</p>\n<ul>\n<li>메소드가 한 가지 책임만 가지도록 구현한다.</li>\n<li>indent(들여쓰기) 깊이를 1단계로 유지한다. </li>\n<li><code class=\"language-text\">else</code> 를 사용하지 마라.</li>\n</ul>\n<p>위 3가지 원칙을 제시하는 이유는 \"<strong>소스코드를 최대한 깔끔하게 구현할 것을 요구하기 위함</strong>\"이다. 초보 프로그래머의 경우, 구현에 있어 막막한 경우가 많다. 이러한 막막함을 해소하기 위해 위 3가지 원칙을 제시한다. (물론 무조건 위 원칙을 지킬 수는 없지만, 최대한 지키도록 노력하면 좀 더 깔끔한 코드를 작성할 수 있을 것이다.)</p>\n<h3>🔧 테스트와 리팩토링을 통한 문자열 계산기 구현</h3>\n<p>요구사항의 복잡도가 높을 수록, 당연히 구현의 복잡도가 증가할 수밖에 없다. 하지만 개발자라면 이러한 복잡도와 평생 부대끼며 살아가야 한다. </p>\n<p>그렇다면 이 복잡도를 낮출 수 있는 방법을 찾아야 하지 않겠는가. 그 방법 중 하나가 끊임없는 리팩토링을 통해 소스코드를 깔끔하게 구현하는 연습을 하는 것이다.</p>\n<p><strong>🧭 요구사항을 작은 단위로 나누기</strong></p>\n<ul>\n<li>복잡한 문제를 풀기 위한 첫 번째 작업은 \"<strong>복잡한 문제를 작은 단위로 나눠 좀 더 쉬운 문제로 변형</strong>\"하는 것이다. 하지만 이러한 작업은 쉽지 않기에 다양한 문제를 해결함으로써 연습하는 수밖에 없다.</li>\n</ul>\n<p><strong>🧭 모든 단계의 끝은 리팩토링</strong></p>\n<ul>\n<li>소스코드의 복잡도가 쉽게 증가하는 이유는 \"<strong>하나의 요구사항을 완료한 후 리팩토링을 하지 않은 상태에서 다음 단계로 이동</strong>\"하기 때문이다. 다음 단계로 넘어가기 위한 마지막 작업은 <strong>결과를 확인한 후 리팩토링까지 완료</strong>하는 것이다.</li>\n</ul>\n<p><strong>🧭 문자열 계산기 구현</strong></p>\n<ul>\n<li><strong>빈 문자열 또는 null 값을 입력할 경우 0을 반환해야 한다.</strong> (ex. <code class=\"language-text\">\"\"</code> => <code class=\"language-text\">0</code>, <code class=\"language-text\">null</code> => <code class=\"language-text\">0</code>)</li>\n</ul>\n<p><code class=\"language-text\">StringCalculator.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        return 0;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}</code>\n        </deckgo-highlight-code>\n<p><code class=\"language-text\">StringCalculatorTest.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    private StringCalculator cal;\n\n    @Before\n    public void setup() {\n        cal = new StringCalculator();\n    }\n    \n    @Test\n    public void add_null_또는_빈문자() {\n        assertEquals(0, cal.add(null));\n        assertEquals(0, cal.add(&quot;&quot;));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>구현에 있어 특별한 점은 없지만, 한 가지 눈여겨 볼 것은 테스트 메소드 이름에 <strong>한글</strong>을 사용했다는 것이다. 테스트 메소드의 정확한 의미 전달을 위해 한글로 작성할 수도 있다.</li>\n</ul>\n<p><strong>🧭 숫자 하나를 문자열로 입력할 경우 해당 숫자를 반환한다.</strong> (ex. \"1\" => 1)</p>\n<p><code class=\"language-text\">StringCalculator.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        return Integer.parseInt(text);\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}</code>\n        </deckgo-highlight-code>\n<p><code class=\"language-text\">StringCalculatorTest.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    ...\n\n    @Test\n    public void add_숫자하나() throws Exception {\n        assertEquals(1, cal.add(&quot;1&quot;));\n    }\n}</code>\n        </deckgo-highlight-code>\n<p><strong>🧭 숫자 두 개를 쉼표 구분자로 입력할 경우 두 숫자의 합을 반환한다.</strong> (ex. \"1,2\" => 3)</p>\n<p><code class=\"language-text\">StringCalculator.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        if (text.contains(&quot;,&quot;)) {\n            String[] values = text.split(&quot;,&quot;);\n            int sum = 0;\n            for (String value : values) {\n                sum += Integer.parseInt(value);\n            }\n            return sum;\n        }\n\n        return Integer.parseInt(text);\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}</code>\n        </deckgo-highlight-code>\n<p><code class=\"language-text\">StringCalculatorTest.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    ...\n\n    @Test\n    public void add_쉼표구분자() throws Exception {\n        assertEquals(3, cal.add(&quot;1,2&quot;));\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>위와 같은 로직을 구현할 때 보통 <code class=\"language-text\">if</code>, <code class=\"language-text\">else if</code>, <code class=\"language-text\">else</code> 형태로 구현하는 것이 일반적이지만 3가지 원칙 중 하나인 \"else를 가능한 사용하지 말라\"에 따라 <code class=\"language-text\">else</code> 를 사용하지 않고 구현했다.</li>\n</ul>\n<p>구현 완료 후 테스트까지 정상적으로 작동했다. 이제는 리팩토링을 할 차례이다. </p>\n<ul>\n<li>첫 번째로, \"<strong>숫자가 하나인 경우</strong>와 <strong>쉼표 구분자를 포함하는 경우</strong>를 따로 분기해서 처리해야 한다\"는 점이다.</li>\n<li><code class=\"language-text\">String</code> 의 <code class=\"language-text\">split()</code> 메소드에 숫자 하나를 가지는 문자열을 전달했을 때, 숫자 하나가 담긴 <code class=\"language-text\">String[]</code> 을 반환한다면 해당 부분의 <code class=\"language-text\">if</code> 문을 제거할 수 있을 것 같다.</li>\n</ul>\n<p><code class=\"language-text\">SplitTest.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.*;\n\nimport org.junit.Test;\n\npublic class SplitTest {\n    @Test\n    public void split() {\n        assertArrayEquals(new String[] {&quot;1&quot;}, &quot;1&quot;.split(&quot;,&quot;));\n        assertArrayEquals(new String[] {&quot;1&quot;,&quot;2&quot;}, &quot;1,2&quot;.split(&quot;,&quot;));\n    }\n}</code>\n        </deckgo-highlight-code>\n<p><code class=\"language-text\">StringCalculator.java</code></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        String[] values = text.split(&quot;,&quot;);\n        int sum = 0;\n        for (String value : values) {\n            sum += Integer.parseInt(value);\n        }\n        return sum;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">SplitTest</code> 의 테스트 코드가 정상적으로 동작하므로, 위와 같이 리팩토링했다.</li>\n<li><code class=\"language-text\">if</code> 절 하나를 제거해 더 깔끔하게 만들었다. </li>\n<li>하지만 <code class=\"language-text\">add()</code> 메소드의 복잡도가 증가하고 있어 <strong>숫자의 합을 구하는 부분을 별도의 메소드로 분리</strong>할 수 있을 것 같다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        String[] values = text.split(&quot;,&quot;);\n        return sum(values);\n    }\n\n    private int sum(String[] values) {\n        int sum = 0;\n        for (String value : values) {\n            sum += Integer.parseInt(value);\n        }\n        return sum;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\"각 메소드가 하나의 책임만 수행하고 있는가?\" 질문에 대해 생각해보면, 새로 분리한 <code class=\"language-text\">sum()</code> 메소드가 <strong>문자열 배열을 숫자로 변환하는 작업</strong>과 <strong>숫자 배열의 합을 구하는 작업</strong>을 하고 있음을 알 수 있다.</li>\n<li>따라서 다음과 같이 분리한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        String[] values = text.split(&quot;,&quot;);\n        return sum(toInts(values));\n    }\n\n    private int[] toInts(String[] values) {\n        int[] numbers = new int[values.length];\n        for (int i = 0; i &lt; values.length; i++) {\n            numbers[i] = Integer.parseInt(values[i]);\n        }\n        return numbers;\n    }\n    \n    private int sum(int[] numbers) {\n        int sum = 0;\n        for (int number : numbers) {\n            sum += number;\n        }\n        return sum;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>소스 코드 복잡도가 감소하는 것이 아니라 오히려 복잡해진 느낌이다. 이는 그저 연습이기 때문이다.</p>\n<ul>\n<li>실제 프로젝트에서 모든 소스코드에 대해 이 같은 리팩토링을 진행할 수 없다. 하지만 이런 작은 코드에서 극단적으로 리팩토링을 하는 연습을 통해 실제 프로젝트에서 리팩토링할 부분을 더 쉽게 찾아 수행할 수 있다.</li>\n</ul>\n</li>\n<li>\n<p>리팩토링한 후 주의 깊게 봐야할 부분은 <code class=\"language-text\">private</code> 로 분리한 메소드가 아닌 <code class=\"language-text\">public</code> 으로 공개하고 있는 <code class=\"language-text\">add()</code> 메소드가 얼마나 읽기 쉽고, 좋은가이다. </p>\n<ul>\n<li>좀 더 극단적으로 리팩토링한다면 <code class=\"language-text\">text == null || text.isEmpty()</code> 또한 다른 메소드로 추출할 수도 있다.</li>\n<li>이와 같이 극단적으로 리팩토링하여 소스코드를 읽을 때 해당 메소드가 어떤 작업을 수행하는지를 최대한 쉽게 파악할 수 있을 것이다. 세부 구현은 <code class=\"language-text\">private</code> 메소드로 분리하고 <code class=\"language-text\">add()</code> 메소드가 무슨 일을 하는 지 글로 표현해보면 \"text 값이 비어 있으면 0을 반환, 비어있지 않으면 구분자로 분리, 숫자로 변환한 다음 이 숫자의 합을 구한다.\" 로 파악할 수 있다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>\"세부 구현에 집중하도록 하지 않고 논리적인 로직을 쉽게 파악할 수 있도록 구현하는 것이 읽기 좋은 코드라 생각한다.\"</p>\n</blockquote>\n<p><strong>🧭 구분자를 쉼표 이외에 콜론을 사용할 수 있다.</strong> (ex. \"1,2:3\" => 6)</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    ...\n    \n    @Test\n    public void add_쉼표_또는_콜론_구분자() throws Exception {\n        assertEquals(6, cal.add(&quot;1,2:3&quot;));\n    }\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class StringCalculator {\n    public int add(String text) {\n        if (isBlank(text))\n            return 0;\n\n        return sum(toInts(split(text)));\n    }\n\n    private String[] split(String text) {\n        return text.split(&quot;,|:&quot;);\n    }\n    ...\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>상당히 작은 부분이 수정되었다.</li>\n</ul>\n<p><strong>🧭 \"//\"와 \"\\n\" 문자 사이에 Custom 구분자를 지정할 수 있다.</strong> ex.\"//;\\n1;2;3\" => 6</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Test\npublic void add_custom_구분자() throws Exception {\n    assertEquals(6, cal.add(&quot;//;\\n1;2;3&quot;));\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\npublic class StringCalculator {\n    public int add(String text) {\n        if (isBlank(text)) {\n            return 0;\n        }\n\n        return sum(toInts(split(text)));\n    }\n\n    private String[] split(String text) {\n        Matcher m = Pattern.compile(&quot;//(.)\\n(.*)&quot;).matcher(text);\n        if (m.find()) {\n            String customDelimeter = m.group(1);\n            return m.group(2).split(customDelimeter);\n        }\n        \n        return text.split(&quot;,|:&quot;);\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>Custom 구분자는 정규 표현식을 이용해 문자열을 분리하고 있다. 이를 활용해 복잡한 문자열에서 원하는 문자열을 찾거나 특정한 패턴을 찾을 수 있다.</li>\n</ul>\n<p><strong>🧭 문자열 계산기에 음수를 전달하는 경우 RuntimeException 예외를 throw</strong></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Test(expected = RuntimeException.class)\npublic void add_negative() throws Exception {\n    cal.add(&quot;-1,2,3&quot;);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><strong>JUnit</strong>에서 <strong>기대하는 결과 값이 예외</strong>인 경우 <code class=\"language-text\">@Test</code> annotation의 <code class=\"language-text\">expected</code> 속성에 기대하는 <code class=\"language-text\">Exception</code> 클래스를 전달할 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">...\nprivate int[] toInts(String[] values) {\n    int[] numbers = new int[values.length];\n    for (int i = 0; i &lt; values.length; i++) {\n        numbers[i] = toPositive(values[i]);\n    }\n    return numbers;\n}\n\nprivate int toPositive(String value) {\n    int number = Integer.parseInt(value);\n    if (number &lt; 0) {\n        throw new RuntimeException();\n    }\n    return number;\n}\n...</code>\n        </deckgo-highlight-code>\n<ul>\n<li>요구사항이 변경되면서 메소드의 이름, 변수 이름을 변경하는 것 또한 리팩토링의 중요한 부분이다. </li>\n</ul>\n<p><strong>🧭 각 단계의 개발과정</strong></p>\n<ul>\n<li>구현 => 테스트를 통해 결과 확인 => 리팩토링</li>\n<li>개발자들이 소홀히 하는 부분이 리팩토링이다. 하지만 깔끔하고 읽기 좋은 코드를 구현하기 위해 개발자가 갖추어야 할 중요한 역량이므로 꾸준한 연습이 필요하다.</li>\n</ul>\n<p><strong>🧭 3가지 원칙</strong></p>\n<ul>\n<li>가능한 위에서 언급한 3가지 원칙을 지키도록 노력하자.</li>\n<li>리팩토링할 부분을 찾기 힘들 때, 3가지 원칙을 생각하면서 찾는다면 약간의 힌트는 얻을 수 있을 것이다.</li>\n</ul>\n<p><strong>🧭 극단적인 리팩토링</strong></p>\n<ul>\n<li>프로덕션 코드를 변경하더라도 바로바로 테스트 코드로 검증이 가능했기에 극단적인 리팩토링이 가능했다. </li>\n<li>실제 프로젝트에서도, 리팩토링을 통해 소스코드의 개선을 원한다면, 테스트 코드가 뒷받침되어야 한다.</li>\n</ul>\n<blockquote>\n<p><strong>\"테스트와 리팩토링은 분리할 수 없는 동반자 관계이고 같이 연습해야 한다.\"</strong></p>\n</blockquote>\n<h2>📕 출처</h2>\n<p><strong>자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법</strong> - 박재성</p>","frontmatter":{"title":"📖 2장 문자열 계산기 구현을 통한 테스트와 리팩토링","date":"January 24, 2022","update":"July 23, 2022","tags":["Java","Refactoring","Framework"],"series":"📖 자바 웹 프로그래밍 Next Step"},"fields":{"slug":"/[NextStep]2/","readingTime":{"minutes":25.585}}},"seriesList":{"edges":[{"node":{"id":"f9691a13-3a27-5449-812b-5819a032b5cf","fields":{"slug":"/[NextStep]1/"},"frontmatter":{"title":"📖 1장 첫 번째 양파 껍질 벗기기"}}},{"node":{"id":"0a455dd6-0b0a-5012-adf7-ca17d9590acd","fields":{"slug":"/[NextStep]2/"},"frontmatter":{"title":"📖 2장 문자열 계산기 구현을 통한 테스트와 리팩토링"}}},{"node":{"id":"e95f7d47-9b6c-58c1-a6db-3faa35ba2bfd","fields":{"slug":"/[NextStep]3/"},"frontmatter":{"title":"📖 3장 개발 환경 구축 및 웹 서버 실습 요구사항"}}},{"node":{"id":"f940f29a-3fda-5127-93a7-d4776e581630","fields":{"slug":"/[NextStep]4/"},"frontmatter":{"title":"📖 4장 HTTP 웹 서버 구현을 통해 HTTP 이해하기"}}},{"node":{"id":"e192a3a9-2352-50a1-81fa-c042806ea2a2","fields":{"slug":"/[NextStep]5/"},"frontmatter":{"title":"📖 5장 웹 서버 리팩토링, 서블릿 컨테이너와 서블릿의 관계"}}},{"node":{"id":"9197157a-75bc-5414-8292-da27dd69a4e1","fields":{"slug":"/[NextStep]6/"},"frontmatter":{"title":"📖 6장 서블릿/JSP를 활용해 동적인 웹 애플리케이션 개발하기"}}},{"node":{"id":"4eec34ae-1e1a-5d59-bcd1-ed5f37722bc9","fields":{"slug":"/[NextStep]7/"},"frontmatter":{"title":"📖 7장 DB를 활용해 데이터를 영구적으로 저장하기"}}},{"node":{"id":"b15cc289-ba13-5439-be9b-2ccce07b1516","fields":{"slug":"/[NextStep]8/"},"frontmatter":{"title":"📖 8장 AJAX를 활용해 새로고침 없이 데이터 갱신하기"}}},{"node":{"id":"7c85cb46-2df5-5972-8e38-24208d1e06b5","fields":{"slug":"/[NextStep]9/"},"frontmatter":{"title":"📖 9장 두번째 양파 껍질을 벗기기 위한 중간 점검"}}},{"node":{"id":"43d32ee6-419a-5f7f-a3d5-d720774977fc","fields":{"slug":"/[NextStep]10/"},"frontmatter":{"title":"📖 10장 새로운 MVC 프레임워크 구현을 통한 점진적 개선"}}},{"node":{"id":"168191bb-b6de-5d4d-9d33-b9b8183f3857","fields":{"slug":"/[NextStep]11/"},"frontmatter":{"title":"📖 11장 의존관계 주입(DI)을 통한 테스트하기 쉬운 코드 만들기"}}},{"node":{"id":"361fa9e9-c9e8-568d-8e23-3ccddd10537e","fields":{"slug":"/[NextStep]12/"},"frontmatter":{"title":"📖 12장 확장성 있는 DI 프레임워크로 개선"}}}]},"previous":{"fields":{"slug":"/[NextStep]1/"},"frontmatter":{"title":"📖 1장 첫 번째 양파 껍질 벗기기"}},"next":{"fields":{"slug":"/[NextStep]3/"},"frontmatter":{"title":"📖 3장 개발 환경 구축 및 웹 서버 실습 요구사항"}}},"pageContext":{"id":"0a455dd6-0b0a-5012-adf7-ca17d9590acd","series":"📖 자바 웹 프로그래밍 Next Step","previousPostId":"f9691a13-3a27-5449-812b-5819a032b5cf","nextPostId":"e95f7d47-9b6c-58c1-a6db-3faa35ba2bfd"}},"staticQueryHashes":[]}